// $ANTLR 3.1.3 Mar 18, 2009 10:09:25 vslTree.g 2009-11-10 14:11:30

import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


public class vslTree extends TreeParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "IMAGINERY_TOKEN", "PROG", "CORPS", "FCALL_S", "BLOCK", "FCALL", "ARDEC", "PARAM", "ARRAY", "ARELEM", "INST", "DEC", "FUNC_KW", "IDENT", "PG", "PD", "PROTO_KW", "INT_KW", "VOID_KW", "VIRG", "CG", "CD", "ASSIGN_KW", "RETURN_KW", "PRINT_KW", "READ_KW", "IF_KW", "THEN_KW", "ELSE_KW", "FI_KW", "WHILE_KW", "DO_KW", "OD_KW", "AG", "AD", "PLUS", "MOINS", "MUL", "DIV", "INTEGER", "TEXT", "WS", "COMMENT", "LETTER", "DIGIT", "ASCII"
    };
    public static final int DEC=15;
    public static final int LETTER=47;
    public static final int OD_KW=36;
    public static final int PARAM=11;
    public static final int EOF=-1;
    public static final int INT_KW=21;
    public static final int INST=14;
    public static final int MOINS=40;
    public static final int PROG=5;
    public static final int RETURN_KW=27;
    public static final int IMAGINERY_TOKEN=4;
    public static final int ARELEM=13;
    public static final int IF_KW=30;
    public static final int ARDEC=10;
    public static final int VIRG=23;
    public static final int AD=38;
    public static final int IDENT=17;
    public static final int PLUS=39;
    public static final int FI_KW=33;
    public static final int AG=37;
    public static final int DIGIT=48;
    public static final int ASSIGN_KW=26;
    public static final int COMMENT=46;
    public static final int ARRAY=12;
    public static final int READ_KW=29;
    public static final int INTEGER=43;
    public static final int FCALL=9;
    public static final int DO_KW=35;
    public static final int FUNC_KW=16;
    public static final int ELSE_KW=32;
    public static final int TEXT=44;
    public static final int MUL=41;
    public static final int THEN_KW=31;
    public static final int WS=45;
    public static final int PROTO_KW=20;
    public static final int WHILE_KW=34;
    public static final int CORPS=6;
    public static final int BLOCK=8;
    public static final int ASCII=49;
    public static final int FCALL_S=7;
    public static final int CG=24;
    public static final int DIV=42;
    public static final int CD=25;
    public static final int PRINT_KW=28;
    public static final int PD=19;
    public static final int PG=18;
    public static final int VOID_KW=22;

    // delegates
    // delegators


        public vslTree(TreeNodeStream input) {
            this(input, new RecognizerSharedState());
        }
        public vslTree(TreeNodeStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return vslTree.tokenNames; }
    public String getGrammarFileName() { return "vslTree.g"; }


    public static class program_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "program"
    // vslTree.g:22:1: program : ^( PROG ( unite )+ ) ;
    public final vslTree.program_return program() throws RecognitionException {
        vslTree.program_return retval = new vslTree.program_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree PROG1=null;
        vslTree.unite_return unite2 = null;


        CommonTree PROG1_tree=null;

        try {
            // vslTree.g:22:10: ( ^( PROG ( unite )+ ) )
            // vslTree.g:22:13: ^( PROG ( unite )+ )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            {
            CommonTree _save_last_1 = _last;
            CommonTree _first_1 = null;
            CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
            PROG1=(CommonTree)match(input,PROG,FOLLOW_PROG_in_program58); 
            PROG1_tree = (CommonTree)adaptor.dupNode(PROG1);

            root_1 = (CommonTree)adaptor.becomeRoot(PROG1_tree, root_1);



            match(input, Token.DOWN, null); 
            // vslTree.g:22:20: ( unite )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==FUNC_KW||LA1_0==PROTO_KW) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // vslTree.g:22:20: unite
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_unite_in_program60);
            	    unite2=unite();

            	    state._fsp--;

            	    adaptor.addChild(root_1, unite2.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
            }


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "program"

    public static class unite_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unite"
    // vslTree.g:25:1: unite : ( ^( FUNC_KW type IDENT param_list ^( CORPS statement ) ) | ^( PROTO_KW type param_list ) );
    public final vslTree.unite_return unite() throws RecognitionException {
        vslTree.unite_return retval = new vslTree.unite_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree FUNC_KW3=null;
        CommonTree IDENT5=null;
        CommonTree CORPS7=null;
        CommonTree PROTO_KW9=null;
        vslTree.type_return type4 = null;

        vslTree.param_list_return param_list6 = null;

        vslTree.statement_return statement8 = null;

        vslTree.type_return type10 = null;

        vslTree.param_list_return param_list11 = null;


        CommonTree FUNC_KW3_tree=null;
        CommonTree IDENT5_tree=null;
        CommonTree CORPS7_tree=null;
        CommonTree PROTO_KW9_tree=null;

        try {
            // vslTree.g:25:8: ( ^( FUNC_KW type IDENT param_list ^( CORPS statement ) ) | ^( PROTO_KW type param_list ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==FUNC_KW) ) {
                alt2=1;
            }
            else if ( (LA2_0==PROTO_KW) ) {
                alt2=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // vslTree.g:25:10: ^( FUNC_KW type IDENT param_list ^( CORPS statement ) )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    FUNC_KW3=(CommonTree)match(input,FUNC_KW,FOLLOW_FUNC_KW_in_unite75); 
                    FUNC_KW3_tree = (CommonTree)adaptor.dupNode(FUNC_KW3);

                    root_1 = (CommonTree)adaptor.becomeRoot(FUNC_KW3_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_type_in_unite77);
                    type4=type();

                    state._fsp--;

                    adaptor.addChild(root_1, type4.getTree());
                    _last = (CommonTree)input.LT(1);
                    IDENT5=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_unite79); 
                    IDENT5_tree = (CommonTree)adaptor.dupNode(IDENT5);

                    adaptor.addChild(root_1, IDENT5_tree);

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_param_list_in_unite81);
                    param_list6=param_list();

                    state._fsp--;

                    adaptor.addChild(root_1, param_list6.getTree());
                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_2 = _last;
                    CommonTree _first_2 = null;
                    CommonTree root_2 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    CORPS7=(CommonTree)match(input,CORPS,FOLLOW_CORPS_in_unite84); 
                    CORPS7_tree = (CommonTree)adaptor.dupNode(CORPS7);

                    root_2 = (CommonTree)adaptor.becomeRoot(CORPS7_tree, root_2);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_statement_in_unite86);
                    statement8=statement();

                    state._fsp--;

                    adaptor.addChild(root_2, statement8.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_1, root_2);_last = _save_last_2;
                    }


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 2 :
                    // vslTree.g:26:5: ^( PROTO_KW type param_list )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    PROTO_KW9=(CommonTree)match(input,PROTO_KW,FOLLOW_PROTO_KW_in_unite95); 
                    PROTO_KW9_tree = (CommonTree)adaptor.dupNode(PROTO_KW9);

                    root_1 = (CommonTree)adaptor.becomeRoot(PROTO_KW9_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_type_in_unite97);
                    type10=type();

                    state._fsp--;

                    adaptor.addChild(root_1, type10.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_param_list_in_unite99);
                    param_list11=param_list();

                    state._fsp--;

                    adaptor.addChild(root_1, param_list11.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "unite"

    public static class type_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type"
    // vslTree.g:29:1: type : ( INT_KW | VOID_KW );
    public final vslTree.type_return type() throws RecognitionException {
        vslTree.type_return retval = new vslTree.type_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree INT_KW12=null;
        CommonTree VOID_KW13=null;

        CommonTree INT_KW12_tree=null;
        CommonTree VOID_KW13_tree=null;

        try {
            // vslTree.g:29:7: ( INT_KW | VOID_KW )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==INT_KW) ) {
                alt3=1;
            }
            else if ( (LA3_0==VOID_KW) ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // vslTree.g:29:9: INT_KW
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    INT_KW12=(CommonTree)match(input,INT_KW,FOLLOW_INT_KW_in_type112); 
                    INT_KW12_tree = (CommonTree)adaptor.dupNode(INT_KW12);

                    root_0 = (CommonTree)adaptor.becomeRoot(INT_KW12_tree, root_0);


                    }
                    break;
                case 2 :
                    // vslTree.g:30:5: VOID_KW
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    VOID_KW13=(CommonTree)match(input,VOID_KW,FOLLOW_VOID_KW_in_type119); 
                    VOID_KW13_tree = (CommonTree)adaptor.dupNode(VOID_KW13);

                    root_0 = (CommonTree)adaptor.becomeRoot(VOID_KW13_tree, root_0);


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "type"

    public static class param_list_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "param_list"
    // vslTree.g:33:1: param_list : ^( PARAM ( param )* ) ;
    public final vslTree.param_list_return param_list() throws RecognitionException {
        vslTree.param_list_return retval = new vslTree.param_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree PARAM14=null;
        vslTree.param_return param15 = null;


        CommonTree PARAM14_tree=null;

        try {
            // vslTree.g:33:12: ( ^( PARAM ( param )* ) )
            // vslTree.g:33:14: ^( PARAM ( param )* )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            {
            CommonTree _save_last_1 = _last;
            CommonTree _first_1 = null;
            CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
            PARAM14=(CommonTree)match(input,PARAM,FOLLOW_PARAM_in_param_list132); 
            PARAM14_tree = (CommonTree)adaptor.dupNode(PARAM14);

            root_1 = (CommonTree)adaptor.becomeRoot(PARAM14_tree, root_1);



            if ( input.LA(1)==Token.DOWN ) {
                match(input, Token.DOWN, null); 
                // vslTree.g:33:22: ( param )*
                loop4:
                do {
                    int alt4=2;
                    int LA4_0 = input.LA(1);

                    if ( (LA4_0==ARRAY||LA4_0==IDENT) ) {
                        alt4=1;
                    }


                    switch (alt4) {
                	case 1 :
                	    // vslTree.g:33:22: param
                	    {
                	    _last = (CommonTree)input.LT(1);
                	    pushFollow(FOLLOW_param_in_param_list134);
                	    param15=param();

                	    state._fsp--;

                	    adaptor.addChild(root_1, param15.getTree());

                	    }
                	    break;

                	default :
                	    break loop4;
                    }
                } while (true);


                match(input, Token.UP, null); 
            }adaptor.addChild(root_0, root_1);_last = _save_last_1;
            }


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "param_list"

    public static class param_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "param"
    // vslTree.g:36:1: param : ( IDENT | ^( ARRAY IDENT ) );
    public final vslTree.param_return param() throws RecognitionException {
        vslTree.param_return retval = new vslTree.param_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree IDENT16=null;
        CommonTree ARRAY17=null;
        CommonTree IDENT18=null;

        CommonTree IDENT16_tree=null;
        CommonTree ARRAY17_tree=null;
        CommonTree IDENT18_tree=null;

        try {
            // vslTree.g:36:8: ( IDENT | ^( ARRAY IDENT ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==IDENT) ) {
                alt5=1;
            }
            else if ( (LA5_0==ARRAY) ) {
                alt5=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // vslTree.g:36:10: IDENT
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    IDENT16=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_param149); 
                    IDENT16_tree = (CommonTree)adaptor.dupNode(IDENT16);

                    adaptor.addChild(root_0, IDENT16_tree);


                    }
                    break;
                case 2 :
                    // vslTree.g:37:12: ^( ARRAY IDENT )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    ARRAY17=(CommonTree)match(input,ARRAY,FOLLOW_ARRAY_in_param163); 
                    ARRAY17_tree = (CommonTree)adaptor.dupNode(ARRAY17);

                    root_1 = (CommonTree)adaptor.becomeRoot(ARRAY17_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    IDENT18=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_param165); 
                    IDENT18_tree = (CommonTree)adaptor.dupNode(IDENT18);

                    adaptor.addChild(root_1, IDENT18_tree);


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "param"

    public static class statement_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // vslTree.g:40:1: statement : ( ^( ASSIGN_KW IDENT expression ) | ^( ASSIGN_KW tab_elem expression ) | ^( RETURN_KW expression ) | ^( PRINT_KW print_list ) | ^( READ_KW read_list ) | ^( IF_KW expression statement ( statement )? ) | ^( WHILE_KW expression statement ) | ^( FCALL_S IDENT ( argument_list )? ) | block );
    public final vslTree.statement_return statement() throws RecognitionException {
        vslTree.statement_return retval = new vslTree.statement_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree ASSIGN_KW19=null;
        CommonTree IDENT20=null;
        CommonTree ASSIGN_KW22=null;
        CommonTree RETURN_KW25=null;
        CommonTree PRINT_KW27=null;
        CommonTree READ_KW29=null;
        CommonTree IF_KW31=null;
        CommonTree WHILE_KW35=null;
        CommonTree FCALL_S38=null;
        CommonTree IDENT39=null;
        vslTree.expression_return expression21 = null;

        vslTree.tab_elem_return tab_elem23 = null;

        vslTree.expression_return expression24 = null;

        vslTree.expression_return expression26 = null;

        vslTree.print_list_return print_list28 = null;

        vslTree.read_list_return read_list30 = null;

        vslTree.expression_return expression32 = null;

        vslTree.statement_return statement33 = null;

        vslTree.statement_return statement34 = null;

        vslTree.expression_return expression36 = null;

        vslTree.statement_return statement37 = null;

        vslTree.argument_list_return argument_list40 = null;

        vslTree.block_return block41 = null;


        CommonTree ASSIGN_KW19_tree=null;
        CommonTree IDENT20_tree=null;
        CommonTree ASSIGN_KW22_tree=null;
        CommonTree RETURN_KW25_tree=null;
        CommonTree PRINT_KW27_tree=null;
        CommonTree READ_KW29_tree=null;
        CommonTree IF_KW31_tree=null;
        CommonTree WHILE_KW35_tree=null;
        CommonTree FCALL_S38_tree=null;
        CommonTree IDENT39_tree=null;

        try {
            // vslTree.g:40:11: ( ^( ASSIGN_KW IDENT expression ) | ^( ASSIGN_KW tab_elem expression ) | ^( RETURN_KW expression ) | ^( PRINT_KW print_list ) | ^( READ_KW read_list ) | ^( IF_KW expression statement ( statement )? ) | ^( WHILE_KW expression statement ) | ^( FCALL_S IDENT ( argument_list )? ) | block )
            int alt8=9;
            alt8 = dfa8.predict(input);
            switch (alt8) {
                case 1 :
                    // vslTree.g:40:13: ^( ASSIGN_KW IDENT expression )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    ASSIGN_KW19=(CommonTree)match(input,ASSIGN_KW,FOLLOW_ASSIGN_KW_in_statement179); 
                    ASSIGN_KW19_tree = (CommonTree)adaptor.dupNode(ASSIGN_KW19);

                    root_1 = (CommonTree)adaptor.becomeRoot(ASSIGN_KW19_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    IDENT20=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_statement181); 
                    IDENT20_tree = (CommonTree)adaptor.dupNode(IDENT20);

                    adaptor.addChild(root_1, IDENT20_tree);

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_statement183);
                    expression21=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression21.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 2 :
                    // vslTree.g:41:5: ^( ASSIGN_KW tab_elem expression )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    ASSIGN_KW22=(CommonTree)match(input,ASSIGN_KW,FOLLOW_ASSIGN_KW_in_statement191); 
                    ASSIGN_KW22_tree = (CommonTree)adaptor.dupNode(ASSIGN_KW22);

                    root_1 = (CommonTree)adaptor.becomeRoot(ASSIGN_KW22_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_tab_elem_in_statement193);
                    tab_elem23=tab_elem();

                    state._fsp--;

                    adaptor.addChild(root_1, tab_elem23.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_statement195);
                    expression24=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression24.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 3 :
                    // vslTree.g:42:5: ^( RETURN_KW expression )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    RETURN_KW25=(CommonTree)match(input,RETURN_KW,FOLLOW_RETURN_KW_in_statement203); 
                    RETURN_KW25_tree = (CommonTree)adaptor.dupNode(RETURN_KW25);

                    root_1 = (CommonTree)adaptor.becomeRoot(RETURN_KW25_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_statement205);
                    expression26=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression26.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 4 :
                    // vslTree.g:43:5: ^( PRINT_KW print_list )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    PRINT_KW27=(CommonTree)match(input,PRINT_KW,FOLLOW_PRINT_KW_in_statement213); 
                    PRINT_KW27_tree = (CommonTree)adaptor.dupNode(PRINT_KW27);

                    root_1 = (CommonTree)adaptor.becomeRoot(PRINT_KW27_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_print_list_in_statement215);
                    print_list28=print_list();

                    state._fsp--;

                    adaptor.addChild(root_1, print_list28.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 5 :
                    // vslTree.g:44:5: ^( READ_KW read_list )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    READ_KW29=(CommonTree)match(input,READ_KW,FOLLOW_READ_KW_in_statement223); 
                    READ_KW29_tree = (CommonTree)adaptor.dupNode(READ_KW29);

                    root_1 = (CommonTree)adaptor.becomeRoot(READ_KW29_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_read_list_in_statement225);
                    read_list30=read_list();

                    state._fsp--;

                    adaptor.addChild(root_1, read_list30.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 6 :
                    // vslTree.g:45:5: ^( IF_KW expression statement ( statement )? )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    IF_KW31=(CommonTree)match(input,IF_KW,FOLLOW_IF_KW_in_statement233); 
                    IF_KW31_tree = (CommonTree)adaptor.dupNode(IF_KW31);

                    root_1 = (CommonTree)adaptor.becomeRoot(IF_KW31_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_statement235);
                    expression32=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression32.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_statement_in_statement237);
                    statement33=statement();

                    state._fsp--;

                    adaptor.addChild(root_1, statement33.getTree());
                    // vslTree.g:45:34: ( statement )?
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( ((LA6_0>=FCALL_S && LA6_0<=BLOCK)||(LA6_0>=ASSIGN_KW && LA6_0<=IF_KW)||LA6_0==WHILE_KW) ) {
                        alt6=1;
                    }
                    switch (alt6) {
                        case 1 :
                            // vslTree.g:45:35: statement
                            {
                            _last = (CommonTree)input.LT(1);
                            pushFollow(FOLLOW_statement_in_statement240);
                            statement34=statement();

                            state._fsp--;

                            adaptor.addChild(root_1, statement34.getTree());

                            }
                            break;

                    }


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 7 :
                    // vslTree.g:46:5: ^( WHILE_KW expression statement )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    WHILE_KW35=(CommonTree)match(input,WHILE_KW,FOLLOW_WHILE_KW_in_statement250); 
                    WHILE_KW35_tree = (CommonTree)adaptor.dupNode(WHILE_KW35);

                    root_1 = (CommonTree)adaptor.becomeRoot(WHILE_KW35_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_statement252);
                    expression36=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression36.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_statement_in_statement254);
                    statement37=statement();

                    state._fsp--;

                    adaptor.addChild(root_1, statement37.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 8 :
                    // vslTree.g:47:5: ^( FCALL_S IDENT ( argument_list )? )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    FCALL_S38=(CommonTree)match(input,FCALL_S,FOLLOW_FCALL_S_in_statement262); 
                    FCALL_S38_tree = (CommonTree)adaptor.dupNode(FCALL_S38);

                    root_1 = (CommonTree)adaptor.becomeRoot(FCALL_S38_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    IDENT39=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_statement264); 
                    IDENT39_tree = (CommonTree)adaptor.dupNode(IDENT39);

                    adaptor.addChild(root_1, IDENT39_tree);

                    // vslTree.g:47:21: ( argument_list )?
                    int alt7=2;
                    int LA7_0 = input.LA(1);

                    if ( (LA7_0==FCALL||LA7_0==ARELEM||LA7_0==IDENT||(LA7_0>=PLUS && LA7_0<=INTEGER)) ) {
                        alt7=1;
                    }
                    switch (alt7) {
                        case 1 :
                            // vslTree.g:47:21: argument_list
                            {
                            _last = (CommonTree)input.LT(1);
                            pushFollow(FOLLOW_argument_list_in_statement266);
                            argument_list40=argument_list();

                            state._fsp--;

                            adaptor.addChild(root_1, argument_list40.getTree());

                            }
                            break;

                    }


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 9 :
                    // vslTree.g:48:5: block
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_block_in_statement274);
                    block41=block();

                    state._fsp--;

                    adaptor.addChild(root_0, block41.getTree());

                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class block_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "block"
    // vslTree.g:51:1: block : ( ^( BLOCK declaration suit_inst ) | ^( BLOCK suit_inst ) );
    public final vslTree.block_return block() throws RecognitionException {
        vslTree.block_return retval = new vslTree.block_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree BLOCK42=null;
        CommonTree BLOCK45=null;
        vslTree.declaration_return declaration43 = null;

        vslTree.suit_inst_return suit_inst44 = null;

        vslTree.suit_inst_return suit_inst46 = null;


        CommonTree BLOCK42_tree=null;
        CommonTree BLOCK45_tree=null;

        try {
            // vslTree.g:51:8: ( ^( BLOCK declaration suit_inst ) | ^( BLOCK suit_inst ) )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==BLOCK) ) {
                int LA9_1 = input.LA(2);

                if ( (LA9_1==DOWN) ) {
                    int LA9_2 = input.LA(3);

                    if ( (LA9_2==DEC) ) {
                        alt9=1;
                    }
                    else if ( (LA9_2==INST) ) {
                        alt9=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // vslTree.g:51:10: ^( BLOCK declaration suit_inst )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    BLOCK42=(CommonTree)match(input,BLOCK,FOLLOW_BLOCK_in_block288); 
                    BLOCK42_tree = (CommonTree)adaptor.dupNode(BLOCK42);

                    root_1 = (CommonTree)adaptor.becomeRoot(BLOCK42_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_declaration_in_block290);
                    declaration43=declaration();

                    state._fsp--;

                    adaptor.addChild(root_1, declaration43.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_suit_inst_in_block292);
                    suit_inst44=suit_inst();

                    state._fsp--;

                    adaptor.addChild(root_1, suit_inst44.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 2 :
                    // vslTree.g:52:5: ^( BLOCK suit_inst )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    BLOCK45=(CommonTree)match(input,BLOCK,FOLLOW_BLOCK_in_block300); 
                    BLOCK45_tree = (CommonTree)adaptor.dupNode(BLOCK45);

                    root_1 = (CommonTree)adaptor.becomeRoot(BLOCK45_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_suit_inst_in_block302);
                    suit_inst46=suit_inst();

                    state._fsp--;

                    adaptor.addChild(root_1, suit_inst46.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "block"

    public static class tab_elem_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tab_elem"
    // vslTree.g:56:1: tab_elem : ^( ARELEM IDENT expression ) ;
    public final vslTree.tab_elem_return tab_elem() throws RecognitionException {
        vslTree.tab_elem_return retval = new vslTree.tab_elem_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree ARELEM47=null;
        CommonTree IDENT48=null;
        vslTree.expression_return expression49 = null;


        CommonTree ARELEM47_tree=null;
        CommonTree IDENT48_tree=null;

        try {
            // vslTree.g:56:10: ( ^( ARELEM IDENT expression ) )
            // vslTree.g:56:13: ^( ARELEM IDENT expression )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            {
            CommonTree _save_last_1 = _last;
            CommonTree _first_1 = null;
            CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
            ARELEM47=(CommonTree)match(input,ARELEM,FOLLOW_ARELEM_in_tab_elem318); 
            ARELEM47_tree = (CommonTree)adaptor.dupNode(ARELEM47);

            root_1 = (CommonTree)adaptor.becomeRoot(ARELEM47_tree, root_1);



            match(input, Token.DOWN, null); 
            _last = (CommonTree)input.LT(1);
            IDENT48=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_tab_elem320); 
            IDENT48_tree = (CommonTree)adaptor.dupNode(IDENT48);

            adaptor.addChild(root_1, IDENT48_tree);

            _last = (CommonTree)input.LT(1);
            pushFollow(FOLLOW_expression_in_tab_elem322);
            expression49=expression();

            state._fsp--;

            adaptor.addChild(root_1, expression49.getTree());

            match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
            }


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "tab_elem"

    public static class suit_inst_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "suit_inst"
    // vslTree.g:59:1: suit_inst : ^( INST ( statement )+ ) ;
    public final vslTree.suit_inst_return suit_inst() throws RecognitionException {
        vslTree.suit_inst_return retval = new vslTree.suit_inst_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree INST50=null;
        vslTree.statement_return statement51 = null;


        CommonTree INST50_tree=null;

        try {
            // vslTree.g:59:11: ( ^( INST ( statement )+ ) )
            // vslTree.g:59:13: ^( INST ( statement )+ )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            {
            CommonTree _save_last_1 = _last;
            CommonTree _first_1 = null;
            CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
            INST50=(CommonTree)match(input,INST,FOLLOW_INST_in_suit_inst335); 
            INST50_tree = (CommonTree)adaptor.dupNode(INST50);

            root_1 = (CommonTree)adaptor.becomeRoot(INST50_tree, root_1);



            match(input, Token.DOWN, null); 
            // vslTree.g:59:20: ( statement )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>=FCALL_S && LA10_0<=BLOCK)||(LA10_0>=ASSIGN_KW && LA10_0<=IF_KW)||LA10_0==WHILE_KW) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // vslTree.g:59:20: statement
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_statement_in_suit_inst337);
            	    statement51=statement();

            	    state._fsp--;

            	    adaptor.addChild(root_1, statement51.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);


            match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
            }


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "suit_inst"

    public static class expression_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // vslTree.g:63:1: expression : ( ^( ( PLUS | MOINS | MUL | DIV ) expression expression ) | primaire );
    public final vslTree.expression_return expression() throws RecognitionException {
        vslTree.expression_return retval = new vslTree.expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree set52=null;
        vslTree.expression_return expression53 = null;

        vslTree.expression_return expression54 = null;

        vslTree.primaire_return primaire55 = null;


        CommonTree set52_tree=null;

        try {
            // vslTree.g:63:12: ( ^( ( PLUS | MOINS | MUL | DIV ) expression expression ) | primaire )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( ((LA11_0>=PLUS && LA11_0<=DIV)) ) {
                alt11=1;
            }
            else if ( (LA11_0==FCALL||LA11_0==ARELEM||LA11_0==IDENT||LA11_0==INTEGER) ) {
                alt11=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // vslTree.g:63:14: ^( ( PLUS | MOINS | MUL | DIV ) expression expression )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();set52=(CommonTree)input.LT(1);
                    if ( (input.LA(1)>=PLUS && input.LA(1)<=DIV) ) {
                        input.consume();

                        set52_tree = (CommonTree)adaptor.dupNode(set52);

                        root_1 = (CommonTree)adaptor.becomeRoot(set52_tree, root_1);

                        state.errorRecovery=false;
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_expression363);
                    expression53=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression53.getTree());
                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_expression365);
                    expression54=expression();

                    state._fsp--;

                    adaptor.addChild(root_1, expression54.getTree());

                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;
                case 2 :
                    // vslTree.g:63:62: primaire
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_primaire_in_expression370);
                    primaire55=primaire();

                    state._fsp--;

                    adaptor.addChild(root_0, primaire55.getTree());

                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class primaire_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primaire"
    // vslTree.g:69:1: primaire : ( INTEGER | IDENT | tab_elem | ^( FCALL IDENT ( argument_list )? ) );
    public final vslTree.primaire_return primaire() throws RecognitionException {
        vslTree.primaire_return retval = new vslTree.primaire_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree INTEGER56=null;
        CommonTree IDENT57=null;
        CommonTree FCALL59=null;
        CommonTree IDENT60=null;
        vslTree.tab_elem_return tab_elem58 = null;

        vslTree.argument_list_return argument_list61 = null;


        CommonTree INTEGER56_tree=null;
        CommonTree IDENT57_tree=null;
        CommonTree FCALL59_tree=null;
        CommonTree IDENT60_tree=null;

        try {
            // vslTree.g:69:10: ( INTEGER | IDENT | tab_elem | ^( FCALL IDENT ( argument_list )? ) )
            int alt13=4;
            switch ( input.LA(1) ) {
            case INTEGER:
                {
                alt13=1;
                }
                break;
            case IDENT:
                {
                alt13=2;
                }
                break;
            case ARELEM:
                {
                alt13=3;
                }
                break;
            case FCALL:
                {
                alt13=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }

            switch (alt13) {
                case 1 :
                    // vslTree.g:69:12: INTEGER
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    INTEGER56=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_primaire384); 
                    INTEGER56_tree = (CommonTree)adaptor.dupNode(INTEGER56);

                    adaptor.addChild(root_0, INTEGER56_tree);


                    }
                    break;
                case 2 :
                    // vslTree.g:70:5: IDENT
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    IDENT57=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_primaire390); 
                    IDENT57_tree = (CommonTree)adaptor.dupNode(IDENT57);

                    adaptor.addChild(root_0, IDENT57_tree);


                    }
                    break;
                case 3 :
                    // vslTree.g:71:11: tab_elem
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_tab_elem_in_primaire402);
                    tab_elem58=tab_elem();

                    state._fsp--;

                    adaptor.addChild(root_0, tab_elem58.getTree());

                    }
                    break;
                case 4 :
                    // vslTree.g:72:5: ^( FCALL IDENT ( argument_list )? )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    FCALL59=(CommonTree)match(input,FCALL,FOLLOW_FCALL_in_primaire409); 
                    FCALL59_tree = (CommonTree)adaptor.dupNode(FCALL59);

                    root_1 = (CommonTree)adaptor.becomeRoot(FCALL59_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    IDENT60=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_primaire411); 
                    IDENT60_tree = (CommonTree)adaptor.dupNode(IDENT60);

                    adaptor.addChild(root_1, IDENT60_tree);

                    // vslTree.g:72:19: ( argument_list )?
                    int alt12=2;
                    int LA12_0 = input.LA(1);

                    if ( (LA12_0==FCALL||LA12_0==ARELEM||LA12_0==IDENT||(LA12_0>=PLUS && LA12_0<=INTEGER)) ) {
                        alt12=1;
                    }
                    switch (alt12) {
                        case 1 :
                            // vslTree.g:72:19: argument_list
                            {
                            _last = (CommonTree)input.LT(1);
                            pushFollow(FOLLOW_argument_list_in_primaire413);
                            argument_list61=argument_list();

                            state._fsp--;

                            adaptor.addChild(root_1, argument_list61.getTree());

                            }
                            break;

                    }


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "primaire"

    public static class argument_list_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "argument_list"
    // vslTree.g:76:1: argument_list : expression ( expression )* ;
    public final vslTree.argument_list_return argument_list() throws RecognitionException {
        vslTree.argument_list_return retval = new vslTree.argument_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        vslTree.expression_return expression62 = null;

        vslTree.expression_return expression63 = null;



        try {
            // vslTree.g:76:15: ( expression ( expression )* )
            // vslTree.g:76:17: expression ( expression )*
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            pushFollow(FOLLOW_expression_in_argument_list427);
            expression62=expression();

            state._fsp--;

            adaptor.addChild(root_0, expression62.getTree());
            // vslTree.g:76:28: ( expression )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( (LA14_0==FCALL||LA14_0==ARELEM||LA14_0==IDENT||(LA14_0>=PLUS && LA14_0<=INTEGER)) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // vslTree.g:76:29: expression
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_expression_in_argument_list430);
            	    expression63=expression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, expression63.getTree());

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "argument_list"

    public static class print_list_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "print_list"
    // vslTree.g:79:1: print_list : print_item ( print_item )* ;
    public final vslTree.print_list_return print_list() throws RecognitionException {
        vslTree.print_list_return retval = new vslTree.print_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        vslTree.print_item_return print_item64 = null;

        vslTree.print_item_return print_item65 = null;



        try {
            // vslTree.g:79:12: ( print_item ( print_item )* )
            // vslTree.g:79:14: print_item ( print_item )*
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            pushFollow(FOLLOW_print_item_in_print_list443);
            print_item64=print_item();

            state._fsp--;

            adaptor.addChild(root_0, print_item64.getTree());
            // vslTree.g:79:25: ( print_item )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( (LA15_0==FCALL||LA15_0==ARELEM||LA15_0==IDENT||(LA15_0>=PLUS && LA15_0<=TEXT)) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // vslTree.g:79:26: print_item
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_print_item_in_print_list446);
            	    print_item65=print_item();

            	    state._fsp--;

            	    adaptor.addChild(root_0, print_item65.getTree());

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "print_list"

    public static class print_item_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "print_item"
    // vslTree.g:82:1: print_item : ( TEXT | expression );
    public final vslTree.print_item_return print_item() throws RecognitionException {
        vslTree.print_item_return retval = new vslTree.print_item_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree TEXT66=null;
        vslTree.expression_return expression67 = null;


        CommonTree TEXT66_tree=null;

        try {
            // vslTree.g:82:12: ( TEXT | expression )
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==TEXT) ) {
                alt16=1;
            }
            else if ( (LA16_0==FCALL||LA16_0==ARELEM||LA16_0==IDENT||(LA16_0>=PLUS && LA16_0<=INTEGER)) ) {
                alt16=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // vslTree.g:82:14: TEXT
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    TEXT66=(CommonTree)match(input,TEXT,FOLLOW_TEXT_in_print_item459); 
                    TEXT66_tree = (CommonTree)adaptor.dupNode(TEXT66);

                    adaptor.addChild(root_0, TEXT66_tree);


                    }
                    break;
                case 2 :
                    // vslTree.g:83:5: expression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_expression_in_print_item465);
                    expression67=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, expression67.getTree());

                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "print_item"

    public static class read_list_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "read_list"
    // vslTree.g:86:1: read_list : read_item ( read_item )* ;
    public final vslTree.read_list_return read_list() throws RecognitionException {
        vslTree.read_list_return retval = new vslTree.read_list_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        vslTree.read_item_return read_item68 = null;

        vslTree.read_item_return read_item69 = null;



        try {
            // vslTree.g:86:11: ( read_item ( read_item )* )
            // vslTree.g:86:13: read_item ( read_item )*
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            pushFollow(FOLLOW_read_item_in_read_list476);
            read_item68=read_item();

            state._fsp--;

            adaptor.addChild(root_0, read_item68.getTree());
            // vslTree.g:86:22: ( read_item )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==ARELEM||LA17_0==IDENT) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // vslTree.g:86:23: read_item
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_read_item_in_read_list478);
            	    read_item69=read_item();

            	    state._fsp--;

            	    adaptor.addChild(root_0, read_item69.getTree());

            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "read_list"

    public static class read_item_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "read_item"
    // vslTree.g:89:1: read_item : ( IDENT | tab_elem );
    public final vslTree.read_item_return read_item() throws RecognitionException {
        vslTree.read_item_return retval = new vslTree.read_item_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree IDENT70=null;
        vslTree.tab_elem_return tab_elem71 = null;


        CommonTree IDENT70_tree=null;

        try {
            // vslTree.g:89:11: ( IDENT | tab_elem )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==IDENT) ) {
                alt18=1;
            }
            else if ( (LA18_0==ARELEM) ) {
                alt18=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // vslTree.g:89:13: IDENT
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    IDENT70=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_read_item491); 
                    IDENT70_tree = (CommonTree)adaptor.dupNode(IDENT70);

                    adaptor.addChild(root_0, IDENT70_tree);


                    }
                    break;
                case 2 :
                    // vslTree.g:90:5: tab_elem
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    pushFollow(FOLLOW_tab_elem_in_read_item497);
                    tab_elem71=tab_elem();

                    state._fsp--;

                    adaptor.addChild(root_0, tab_elem71.getTree());

                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "read_item"

    public static class declaration_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "declaration"
    // vslTree.g:93:1: declaration : ^( DEC ( dec_item )+ ) ;
    public final vslTree.declaration_return declaration() throws RecognitionException {
        vslTree.declaration_return retval = new vslTree.declaration_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree DEC72=null;
        vslTree.dec_item_return dec_item73 = null;


        CommonTree DEC72_tree=null;

        try {
            // vslTree.g:93:13: ( ^( DEC ( dec_item )+ ) )
            // vslTree.g:93:15: ^( DEC ( dec_item )+ )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            {
            CommonTree _save_last_1 = _last;
            CommonTree _first_1 = null;
            CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
            DEC72=(CommonTree)match(input,DEC,FOLLOW_DEC_in_declaration509); 
            DEC72_tree = (CommonTree)adaptor.dupNode(DEC72);

            root_1 = (CommonTree)adaptor.becomeRoot(DEC72_tree, root_1);



            match(input, Token.DOWN, null); 
            // vslTree.g:93:21: ( dec_item )+
            int cnt19=0;
            loop19:
            do {
                int alt19=2;
                int LA19_0 = input.LA(1);

                if ( (LA19_0==ARDEC||LA19_0==IDENT) ) {
                    alt19=1;
                }


                switch (alt19) {
            	case 1 :
            	    // vslTree.g:93:21: dec_item
            	    {
            	    _last = (CommonTree)input.LT(1);
            	    pushFollow(FOLLOW_dec_item_in_declaration511);
            	    dec_item73=dec_item();

            	    state._fsp--;

            	    adaptor.addChild(root_1, dec_item73.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt19 >= 1 ) break loop19;
                        EarlyExitException eee =
                            new EarlyExitException(19, input);
                        throw eee;
                }
                cnt19++;
            } while (true);


            match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
            }


            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "declaration"

    public static class dec_item_return extends TreeRuleReturnScope {
        CommonTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "dec_item"
    // vslTree.g:96:1: dec_item : ( IDENT | ^( ARDEC IDENT INTEGER ) );
    public final vslTree.dec_item_return dec_item() throws RecognitionException {
        vslTree.dec_item_return retval = new vslTree.dec_item_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree IDENT74=null;
        CommonTree ARDEC75=null;
        CommonTree IDENT76=null;
        CommonTree INTEGER77=null;

        CommonTree IDENT74_tree=null;
        CommonTree ARDEC75_tree=null;
        CommonTree IDENT76_tree=null;
        CommonTree INTEGER77_tree=null;

        try {
            // vslTree.g:96:10: ( IDENT | ^( ARDEC IDENT INTEGER ) )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==IDENT) ) {
                alt20=1;
            }
            else if ( (LA20_0==ARDEC) ) {
                alt20=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // vslTree.g:96:12: IDENT
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    IDENT74=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_dec_item525); 
                    IDENT74_tree = (CommonTree)adaptor.dupNode(IDENT74);

                    adaptor.addChild(root_0, IDENT74_tree);


                    }
                    break;
                case 2 :
                    // vslTree.g:97:14: ^( ARDEC IDENT INTEGER )
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    _last = (CommonTree)input.LT(1);
                    {
                    CommonTree _save_last_1 = _last;
                    CommonTree _first_1 = null;
                    CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
                    ARDEC75=(CommonTree)match(input,ARDEC,FOLLOW_ARDEC_in_dec_item541); 
                    ARDEC75_tree = (CommonTree)adaptor.dupNode(ARDEC75);

                    root_1 = (CommonTree)adaptor.becomeRoot(ARDEC75_tree, root_1);



                    match(input, Token.DOWN, null); 
                    _last = (CommonTree)input.LT(1);
                    IDENT76=(CommonTree)match(input,IDENT,FOLLOW_IDENT_in_dec_item543); 
                    IDENT76_tree = (CommonTree)adaptor.dupNode(IDENT76);

                    adaptor.addChild(root_1, IDENT76_tree);

                    _last = (CommonTree)input.LT(1);
                    INTEGER77=(CommonTree)match(input,INTEGER,FOLLOW_INTEGER_in_dec_item545); 
                    INTEGER77_tree = (CommonTree)adaptor.dupNode(INTEGER77);

                    adaptor.addChild(root_1, INTEGER77_tree);


                    match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
                    }


                    }
                    break;

            }
            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "dec_item"

    // Delegated rules


    protected DFA8 dfa8 = new DFA8(this);
    static final String DFA8_eotS =
        "\14\uffff";
    static final String DFA8_eofS =
        "\14\uffff";
    static final String DFA8_minS =
        "\1\7\1\2\7\uffff\1\15\2\uffff";
    static final String DFA8_maxS =
        "\1\42\1\2\7\uffff\1\21\2\uffff";
    static final String DFA8_acceptS =
        "\2\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\uffff\1\1\1\2";
    static final String DFA8_specialS =
        "\14\uffff}>";
    static final String[] DFA8_transitionS = {
            "\1\7\1\10\21\uffff\1\1\1\2\1\3\1\4\1\5\3\uffff\1\6",
            "\1\11",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\13\3\uffff\1\12",
            "",
            ""
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "40:1: statement : ( ^( ASSIGN_KW IDENT expression ) | ^( ASSIGN_KW tab_elem expression ) | ^( RETURN_KW expression ) | ^( PRINT_KW print_list ) | ^( READ_KW read_list ) | ^( IF_KW expression statement ( statement )? ) | ^( WHILE_KW expression statement ) | ^( FCALL_S IDENT ( argument_list )? ) | block );";
        }
    }
 

    public static final BitSet FOLLOW_PROG_in_program58 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_unite_in_program60 = new BitSet(new long[]{0x0000000000110008L});
    public static final BitSet FOLLOW_FUNC_KW_in_unite75 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_type_in_unite77 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_IDENT_in_unite79 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_param_list_in_unite81 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_CORPS_in_unite84 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_statement_in_unite86 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_PROTO_KW_in_unite95 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_type_in_unite97 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_param_list_in_unite99 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_INT_KW_in_type112 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_KW_in_type119 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARAM_in_param_list132 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_param_in_param_list134 = new BitSet(new long[]{0x0000000000021008L});
    public static final BitSet FOLLOW_IDENT_in_param149 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ARRAY_in_param163 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_param165 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_ASSIGN_KW_in_statement179 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_statement181 = new BitSet(new long[]{0x00000F8000022200L});
    public static final BitSet FOLLOW_expression_in_statement183 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_ASSIGN_KW_in_statement191 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_tab_elem_in_statement193 = new BitSet(new long[]{0x00000F8000022200L});
    public static final BitSet FOLLOW_expression_in_statement195 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_RETURN_KW_in_statement203 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_statement205 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_PRINT_KW_in_statement213 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_print_list_in_statement215 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_READ_KW_in_statement223 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_read_list_in_statement225 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_IF_KW_in_statement233 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_statement235 = new BitSet(new long[]{0x000000047C000180L});
    public static final BitSet FOLLOW_statement_in_statement237 = new BitSet(new long[]{0x000000047C000188L});
    public static final BitSet FOLLOW_statement_in_statement240 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_WHILE_KW_in_statement250 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_statement252 = new BitSet(new long[]{0x000000047C000180L});
    public static final BitSet FOLLOW_statement_in_statement254 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_FCALL_S_in_statement262 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_statement264 = new BitSet(new long[]{0x00000F8000022208L});
    public static final BitSet FOLLOW_argument_list_in_statement266 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_block_in_statement274 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BLOCK_in_block288 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_declaration_in_block290 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_suit_inst_in_block292 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_BLOCK_in_block300 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_suit_inst_in_block302 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_ARELEM_in_tab_elem318 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_tab_elem320 = new BitSet(new long[]{0x00000F8000022200L});
    public static final BitSet FOLLOW_expression_in_tab_elem322 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_INST_in_suit_inst335 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_statement_in_suit_inst337 = new BitSet(new long[]{0x000000047C000188L});
    public static final BitSet FOLLOW_set_in_expression353 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_expression_in_expression363 = new BitSet(new long[]{0x00000F8000022200L});
    public static final BitSet FOLLOW_expression_in_expression365 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_primaire_in_expression370 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTEGER_in_primaire384 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENT_in_primaire390 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tab_elem_in_primaire402 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FCALL_in_primaire409 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_primaire411 = new BitSet(new long[]{0x00000F8000022208L});
    public static final BitSet FOLLOW_argument_list_in_primaire413 = new BitSet(new long[]{0x0000000000000008L});
    public static final BitSet FOLLOW_expression_in_argument_list427 = new BitSet(new long[]{0x00000F8000022202L});
    public static final BitSet FOLLOW_expression_in_argument_list430 = new BitSet(new long[]{0x00000F8000022202L});
    public static final BitSet FOLLOW_print_item_in_print_list443 = new BitSet(new long[]{0x00001F8000022202L});
    public static final BitSet FOLLOW_print_item_in_print_list446 = new BitSet(new long[]{0x00001F8000022202L});
    public static final BitSet FOLLOW_TEXT_in_print_item459 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_print_item465 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_read_item_in_read_list476 = new BitSet(new long[]{0x0000000000022002L});
    public static final BitSet FOLLOW_read_item_in_read_list478 = new BitSet(new long[]{0x0000000000022002L});
    public static final BitSet FOLLOW_IDENT_in_read_item491 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tab_elem_in_read_item497 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEC_in_declaration509 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_dec_item_in_declaration511 = new BitSet(new long[]{0x0000000000020408L});
    public static final BitSet FOLLOW_IDENT_in_dec_item525 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ARDEC_in_dec_item541 = new BitSet(new long[]{0x0000000000000004L});
    public static final BitSet FOLLOW_IDENT_in_dec_item543 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_INTEGER_in_dec_item545 = new BitSet(new long[]{0x0000000000000008L});

}